home *** CD-ROM | disk | FTP | other *** search
/ Freelog 22 / freelog 22.iso / Prog / Djgpp / GPC2952B.ZIP / info / gpc.i22 < prev    next >
Encoding:
GNU Info File  |  2001-02-09  |  40.4 KB  |  760 lines
  1. This is gpc.info, produced by makeinfo version 4.0 from gpc.texi.
  2.  
  3. INFO-DIR-SECTION GNU programming tools
  4. START-INFO-DIR-ENTRY
  5. * GPC: (gpc).                   The GNU Pascal Compiler.
  6. END-INFO-DIR-ENTRY
  7. INFO-DIR-SECTION Individual utilities
  8. START-INFO-DIR-ENTRY
  9. * GPC: (gpc)Invoking GPC.       The GNU Pascal Compiler.
  10. END-INFO-DIR-ENTRY
  11.  
  12.    This file documents the GNU Pascal Compiler.
  13.  
  14.    Copyright (C) 1988, 1996-2001 Free Software Foundation, Inc.
  15.  
  16.    Permission is granted to make and distribute verbatim copies of this
  17. manual provided the copyright notice and this permission notice are
  18. preserved on all copies.
  19.  
  20.    Permission is granted to copy and distribute modified versions of
  21. this manual under the conditions for verbatim copying, provided also
  22. that the sections entitled "GNU General Public License", "The GNU
  23. Project", "The GNU Manifesto" and "Funding for Free Software" are
  24. included exactly as in the original, and provided that the entire
  25. resulting derived work is distributed under the terms of a permission
  26. notice identical to this one.
  27.  
  28.    Permission is granted to copy and distribute translations of this
  29. manual into another language, under the above conditions for modified
  30. versions, except that the sections entitled "GNU General Public
  31. License", "The GNU Project", "The GNU Manifesto" and "Funding for Free
  32. Software" and this permission notice, may be included in translations
  33. approved by the Free Software Foundation instead of in the original
  34. English.
  35.  
  36. 
  37. File: gpc.info,  Node: GPC Index,  Prev: GNU,  Up: Top
  38.  
  39. GPC Index
  40. *********
  41.  
  42. * Menu:
  43.  
  44. * *:                                     Complex Number Operations.
  45. * **:                                    Complex Number Operations.
  46. * + <1>:                                 Complex Number Operations.
  47. * +:                                     String Operations.
  48. * -:                                     Complex Number Operations.
  49. * -amtmpfile:                            GPC Command Line Options.
  50. * -autobuild:                            GPC Command Line Options.
  51. * -autolink:                             GPC Command Line Options.
  52. * -automake:                             GPC Command Line Options.
  53. * -borland-char-constants:               GPC Command Line Options.
  54. * -borland-pascal:                       GPC Command Line Options.
  55. * -cidefine:                             GPC Command Line Options.
  56. * -csdefine:                             GPC Command Line Options.
  57. * -debug-gpi:                            GPC Command Line Options.
  58. * -debug-source:                         GPC Command Line Options.
  59. * -debug-tree:                           GPC Command Line Options.
  60. * -delphi:                               GPC Command Line Options.
  61. * -delphi-comments:                      GPC Command Line Options.
  62. * -exact-compare-strings:                GPC Command Line Options.
  63. * -executable-file-name:                 GPC Command Line Options.
  64. * -executable-path:                      GPC Command Line Options.
  65. * -extended-pascal:                      GPC Command Line Options.
  66. * -extended-syntax:                      GPC Command Line Options.
  67. * -field-widths:                         GPC Command Line Options.
  68. * -gnu-pascal:                           GPC Command Line Options.
  69. * -gpc-main <1>:                         Importing Libraries from Other Languages.
  70. * -gpc-main:                             GPC Command Line Options.
  71. * -gpi-destination-path:                 GPC Command Line Options.
  72. * -ignore-function-results:              GPC Command Line Options.
  73. * -implementation-only:                  GPC Command Line Options.
  74. * -interface-only:                       GPC Command Line Options.
  75. * -io-checking:                          GPC Command Line Options.
  76. * -lines:                                GPC Command Line Options.
  77. * -macros:                               GPC Command Line Options.
  78. * -mixed-comments:                       GPC Command Line Options.
  79. * -nested-comments:                      GPC Command Line Options.
  80. * -no-autobuild:                         GPC Command Line Options.
  81. * -no-autolink:                          GPC Command Line Options.
  82. * -no-automake:                          GPC Command Line Options.
  83. * -no-borland-char-constants:            GPC Command Line Options.
  84. * -no-default-paths:                     GPC Command Line Options.
  85. * -no-delphi-comments:                   GPC Command Line Options.
  86. * -no-exact-compare-strings:             GPC Command Line Options.
  87. * -no-executable-path:                   GPC Command Line Options.
  88. * -no-extended-syntax:                   GPC Command Line Options.
  89. * -no-field-widths:                      GPC Command Line Options.
  90. * -no-ignore-function-results:           GPC Command Line Options.
  91. * -no-io-checking:                       GPC Command Line Options.
  92. * -no-macros:                            GPC Command Line Options.
  93. * -no-mixed-comments:                    GPC Command Line Options.
  94. * -no-nested-comments:                   GPC Command Line Options.
  95. * -no-object-destination-path:           GPC Command Line Options.
  96. * -no-object-path:                       GPC Command Line Options.
  97. * -no-pedantic:                          GPC Command Line Options.
  98. * -no-short-circuit:                     GPC Command Line Options.
  99. * -no-signed-char:                       GPC Command Line Options.
  100. * -no-stack-checking:                    GPC Command Line Options.
  101. * -no-transparent-file-names:            GPC Command Line Options.
  102. * -no-truncate-strings:                  GPC Command Line Options.
  103. * -no-typed-address:                     GPC Command Line Options.
  104. * -no-unit-destination-path:             GPC Command Line Options.
  105. * -no-unit-path:                         GPC Command Line Options.
  106. * -no-unsigned-char:                     GPC Command Line Options.
  107. * -no-write-capital-exponent:            GPC Command Line Options.
  108. * -no-write-clip-strings:                GPC Command Line Options.
  109. * -no-write-real-blank:                  GPC Command Line Options.
  110. * -object-destination-path:              GPC Command Line Options.
  111. * -object-pascal:                        GPC Command Line Options.
  112. * -object-path:                          GPC Command Line Options.
  113. * -pascal-sc:                            GPC Command Line Options.
  114. * -pedantic:                             GPC Command Line Options.
  115. * -progress-bar:                         GPC Command Line Options.
  116. * -progress-messages:                    GPC Command Line Options.
  117. * -setlimit:                             GPC Command Line Options.
  118. * -short-circuit:                        GPC Command Line Options.
  119. * -signed-char:                          GPC Command Line Options.
  120. * -stack-checking:                       GPC Command Line Options.
  121. * -standard-pascal:                      GPC Command Line Options.
  122. * -standard-pascal-level-0:              GPC Command Line Options.
  123. * -transparent-file-names:               GPC Command Line Options.
  124. * -truncate-strings:                     GPC Command Line Options.
  125. * -typed-address:                        GPC Command Line Options.
  126. * -unit-destination-path:                GPC Command Line Options.
  127. * -unit-path:                            GPC Command Line Options.
  128. * -unsigned-char:                        GPC Command Line Options.
  129. * -uses:                                 GPC Command Line Options.
  130. * -Wfield-name-problem:                  GPC Command Line Options.
  131. * -Wmixed-comments:                      GPC Command Line Options.
  132. * -Wnear-far:                            GPC Command Line Options.
  133. * -Wnested-comments:                     GPC Command Line Options.
  134. * -Wno-field-name-problem:               GPC Command Line Options.
  135. * -Wno-mixed-comments:                   GPC Command Line Options.
  136. * -Wno-near-far:                         GPC Command Line Options.
  137. * -Wno-nested-comments:                  GPC Command Line Options.
  138. * -Wno-object-directives:                GPC Command Line Options.
  139. * -Wno-typed-const:                      GPC Command Line Options.
  140. * -Wno-underscore:                       GPC Command Line Options.
  141. * -Wno-warnings:                         GPC Command Line Options.
  142. * -Wobject-directives:                   GPC Command Line Options.
  143. * -write-capital-exponent:               GPC Command Line Options.
  144. * -write-clip-strings:                   GPC Command Line Options.
  145. * -write-real-blank:                     GPC Command Line Options.
  146. * -Wtyped-const:                         GPC Command Line Options.
  147. * -Wunderscore:                          GPC Command Line Options.
  148. * -Wwarnings:                            GPC Command Line Options.
  149. * /:                                     Complex Number Operations.
  150. * ><:                                    Set Operations.
  151. * Abs:                                   Abs.
  152. * absolute <1>:                          Keywords.
  153. * absolute:                              absolute.
  154. * abstract <1>:                          Keywords.
  155. * abstract:                              abstract.
  156. * Addr:                                  Addr.
  157. * alignment:                             AlignOf.
  158. * Alignment, Type Implementation:        Alignment.
  159. * AlignOf:                               AlignOf.
  160. * all <1>:                               Keywords.
  161. * all:                                   all.
  162. * and <1>:                               Keywords.
  163. * and <2>:                               and.
  164. * and:                                   Operations for Integer and Ordinal Types.
  165. * and then:                              and then.
  166. * and_then <1>:                          Keywords.
  167. * and_then:                              and_then.
  168. * AnsiChar:                              AnsiChar.
  169. * Append:                                Append.
  170. * ArcTan <1>:                            ArcTan.
  171. * ArcTan:                                Complex Number Operations.
  172. * Arg <1>:                               Arg.
  173. * Arg:                                   Complex Number Operations.
  174. * array <1>:                             Keywords.
  175. * array:                                 array.
  176. * Array Types, Data Types:               Array Types.
  177. * array, conformant:                     Conformant Arrays.
  178. * array, open:                           Open Arrays.
  179. * asm <1>:                               Keywords.
  180. * asm:                                   asm.
  181. * asm, Statements, Source Structure:     asm Inline.
  182. * asmname <1>:                           Keywords.
  183. * asmname <2>:                           asmname.
  184. * asmname:                               Importing Libraries from Other Languages.
  185. * Assign:                                Assign.
  186. * Assigned:                              Assigned.
  187. * Assignment, Statements, Source Structure: Assignment.
  188. * attribute <1>:                         Keywords.
  189. * attribute:                             attribute.
  190. * AutoMake, internals:                   AutoMake.
  191. * begin <1>:                             Keywords.
  192. * begin:                                 begin.
  193. * begin end, Statements, Source Structure: begin end Compound Statement.
  194. * binary distributions, installing:      Binary Distributions.
  195. * Bind <1>:                              Bind.
  196. * Bind:                                  File Routines.
  197. * bindable <1>:                          Keywords.
  198. * bindable:                              bindable.
  199. * Binding <1>:                           Binding.
  200. * Binding:                               File Routines.
  201. * BindingType:                           BindingType.
  202. * bits:                                  BitSizeOf.
  203. * BitSizeOf:                             BitSizeOf.
  204. * BlockRead:                             BlockRead.
  205. * BlockWrite:                            BlockWrite.
  206. * Boolean:                               Boolean.
  207. * Boolean, Intrinsic, Data Types:        Boolean (Intrinsic).
  208. * Break:                                 Break.
  209. * bugs:                                  Support.
  210. * Built-in:                              Library Routines.
  211. * Byte:                                  Byte.
  212. * ByteBool:                              ByteBool.
  213. * ByteCard:                              ByteCard.
  214. * ByteInt:                               ByteInt.
  215. * C <1>:                                 C.
  216. * C <2>:                                 Importing Libraries from Other Languages.
  217. * C:                                     Other Languages.
  218. * C language:                            Importing Libraries from Other Languages.
  219. * C_Language <1>:                        C_Language.
  220. * C_Language:                            Importing Libraries from Other Languages.
  221. * Card <1>:                              Card.
  222. * Card:                                  Set Operations.
  223. * Cardinal:                              Cardinal.
  224. * case <1>:                              Keywords.
  225. * case:                                  case.
  226. * case, Statements, Source Structure:    case Statement.
  227. * Char:                                  Char.
  228. * Char, Intrinsic, Data Types:           Character Types.
  229. * ChDir:                                 ChDir.
  230. * Chr:                                   Chr.
  231. * class <1>:                             Keywords.
  232. * class:                                 class.
  233. * Close:                                 Close.
  234. * Cmplx <1>:                             Cmplx.
  235. * Cmplx:                                 Complex Number Operations.
  236. * command line options:                  Invoking GPC.
  237. * Comp:                                  Comp.
  238. * Compilation notes for specific platforms: Compilation Notes.
  239. * compiler directives:                   Compiler Directives.
  240. * Complex:                               Complex.
  241. * Concat <1>:                            Concat.
  242. * Concat:                                String Operations.
  243. * conformant arrays, internals:          Parameter passing.
  244. * Conjugate:                             Conjugate.
  245. * const <1>:                             Keywords.
  246. * const:                                 const.
  247. * Constant Declaration, Source Structures: Constant Declaration.
  248. * constructor <1>:                       Keywords.
  249. * constructor:                           constructor.
  250. * Continue:                              Continue.
  251. * contributors:                          Contributors.
  252. * Copy:                                  Copy.
  253. * Cos <1>:                               Cos.
  254. * Cos:                                   Complex Number Operations.
  255. * cross-compilers:                       Cross-Compilers.
  256. * crossbuilding:                         Crossbuilding.
  257. * CString:                               CString.
  258. * CString2String:                        CString2String.
  259. * CStringCopyString:                     CStringCopyString.
  260. * CVS <1>:                               Compiling GPC.
  261. * CVS:                                   Download.
  262. * Data Types, Definition:                Type Definition.
  263. * Date <1>:                              Date.
  264. * Date:                                  Date And Time Routines.
  265. * debugging:                             Notes for Debugging.
  266. * Dec <1>:                               Dec.
  267. * Dec:                                   Operations for Integer and Ordinal Types.
  268. * DefineSize:                            DefineSize.
  269. * Delete:                                Delete.
  270. * destructor <1>:                        Keywords.
  271. * destructor:                            destructor.
  272. * Dispose <1>:                           Dispose.
  273. * Dispose:                               Memory Management Routines.
  274. * div <1>:                               Keywords.
  275. * div:                                   div.
  276. * djgpp:                                 MS-DOS with DJGPP.
  277. * do <1>:                                Keywords.
  278. * do:                                    do.
  279. * DOS, MS- <1>:                          MS-DOS or OS/2 with EMX.
  280. * DOS, MS-:                              MS-DOS with DJGPP.
  281. * Double <1>:                            Double.
  282. * Double:                                Real Types.
  283. * download:                              Download.
  284. * downto <1>:                            Keywords.
  285. * downto:                                downto.
  286. * else <1>:                              Keywords.
  287. * else:                                  else.
  288. * Empty:                                 Empty.
  289. * EMX:                                   MS-DOS or OS/2 with EMX.
  290. * end <1>:                               Keywords.
  291. * end:                                   end.
  292. * endianness:                            Endianness.
  293. * Enumerated Types, Data Types:          Enumerated Types.
  294. * EOF:                                   EOF.
  295. * EOLn:                                  EOLn.
  296. * EpsReal:                               EpsReal.
  297. * Eq:                                    Eq.
  298. * Erase:                                 Erase.
  299. * Exclude:                               Exclude.
  300. * Exit:                                  Exit.
  301. * Exp <1>:                               Exp.
  302. * Exp:                                   Complex Number Operations.
  303. * export <1>:                            Keywords.
  304. * export:                                export.
  305. * exports <1>:                           Keywords.
  306. * exports:                               exports.
  307. * Extend:                                Extend.
  308. * Extended <1>:                          Extended.
  309. * Extended:                              Real Types.
  310. * extern <1>:                            extern.
  311. * extern:                                Importing Libraries from Other Languages.
  312. * external <1>:                          Keywords.
  313. * external <2>:                          external.
  314. * external:                              Importing Libraries from Other Languages.
  315. * Fail:                                  Fail.
  316. * False:                                 False.
  317. * FAQ:                                   FAQ.
  318. * far:                                   far.
  319. * file <1>:                              Keywords.
  320. * file:                                  file.
  321. * File Layout, internals:                File Layout.
  322. * File Types, Intrinsic, Data Types:     File Types.
  323. * FileMode:                              FileMode.
  324. * FilePos:                               FilePos.
  325. * FileSize:                              FileSize.
  326. * FillChar:                              FillChar.
  327. * Flush:                                 Flush.
  328. * for <1>:                               Keywords.
  329. * for:                                   for.
  330. * for, Statements, Source Structure:     for Statement.
  331. * forward <1>:                           Keywords.
  332. * forward:                               forward.
  333. * Frac:                                  Frac.
  334. * FrameAddress:                          FrameAddress.
  335. * FreeMem <1>:                           FreeMem.
  336. * FreeMem:                               Memory Management Routines.
  337. * Frequently Asked Questions:            FAQ.
  338. * front-end, internals <1>:              Tree nodes.
  339. * front-end, internals:                  Language definition.
  340. * FTP:                                   Download.
  341. * function <1>:                          Keywords.
  342. * function:                              function.
  343. * function, Subroutine Declaration, Source Structure: The Function.
  344. * functional type:                       Procedural Types.
  345. * functions as parameters, internals:    Parameter passing.
  346. * functions, predefined:                 Library Routines.
  347. * GE:                                    GE.
  348. * Get <1>:                               Get.
  349. * Get:                                   File Routines.
  350. * GetMem <1>:                            GetMem.
  351. * GetMem:                                Memory Management Routines.
  352. * GetTimeStamp <1>:                      GetTimeStamp.
  353. * GetTimeStamp:                          Date And Time Routines.
  354. * GNU:                                   GNU.
  355. * GNU Pascal command line options:       Invoking GPC.
  356. * goto <1>:                              Keywords.
  357. * goto:                                  goto.
  358. * goto, Statements, Source Structure:    goto Statement.
  359. * GPC and other languages:               Other Languages.
  360. * GPC source, internals:                 Internals.
  361. * GPC, internals:                        Internals.
  362. * GPI files, internals:                  GPI files.
  363. * grammar, internals:                    Language definition.
  364. * GT:                                    GT.
  365. * Halt:                                  Halt.
  366. * help:                                  Support.
  367. * High:                                  High.
  368. * highlights:                            Highlights.
  369. * if <1>:                                Keywords.
  370. * if:                                    if.
  371. * if, Statements, Source Structure:      if Statement.
  372. * Im <1>:                                Im.
  373. * Im:                                    Complex Number Operations.
  374. * implementation <1>:                    Keywords.
  375. * implementation:                        implementation.
  376. * import <1>:                            Keywords.
  377. * import:                                import.
  378. * import part <1>:                       Units.
  379. * import part:                           Modules.
  380. * Import Part, Source Structures:        Modules and Units.
  381. * in <1>:                                Keywords.
  382. * in:                                    in.
  383. * Inc <1>:                               Inc.
  384. * Inc:                                   Operations for Integer and Ordinal Types.
  385. * Include:                               Include.
  386. * Index:                                 Index.
  387. * inherited <1>:                         Keywords.
  388. * inherited <2>:                         inherited.
  389. * inherited:                             OOP.
  390. * inline <1>:                            Keywords.
  391. * inline:                                inline.
  392. * InOutRes:                              InOutRes.
  393. * InOutResStr:                           InOutResStr.
  394. * Input:                                 Input.
  395. * Insert:                                Insert.
  396. * installing binary distributions:       Binary Distributions.
  397. * installing GNU Pascal:                 Installation.
  398. * installing source distributions:       Compiling GPC.
  399. * Int:                                   Int.
  400. * Integer:                               Integer.
  401. * Integer types:                         Integer Types.
  402. * integer types, compatibility:          Integer Types and Compatibility.
  403. * integer types, main branch:            Main Branch Integer Types.
  404. * integer types, natural:                Natural Integer Types.
  405. * integer types, specified size:         Integer Types with Specified Size.
  406. * integer types, summary:                Summary of Integer Types.
  407. * interface <1>:                         Keywords.
  408. * interface:                             interface.
  409. * intermediate code, internals:          Tree nodes.
  410. * interrupt <1>:                         Keywords.
  411. * interrupt:                             interrupt.
  412. * IOResult:                              IOResult.
  413. * is <1>:                                Keywords.
  414. * is:                                    is.
  415. * label <1>:                             Keywords.
  416. * label:                                 label.
  417. * Label Declaration, Source Structures:  Label Declaration.
  418. * language definition, internals:        Language definition.
  419. * LastPosition <1>:                      LastPosition.
  420. * LastPosition:                          File Routines.
  421. * LE:                                    LE.
  422. * Length:                                Length.
  423. * lexical analyzer, internals:           Lexical analyzer.
  424. * Libraries:                             GPC Options.
  425. * library <1>:                           Keywords.
  426. * library:                               library.
  427. * linking:                               Importing Libraries from Other Languages.
  428. * Ln <1>:                                Ln.
  429. * Ln:                                    Complex Number Operations.
  430. * LoCase:                                LoCase.
  431. * LongBool:                              LongBool.
  432. * LongCard:                              LongCard.
  433. * LongestBool:                           LongestBool.
  434. * LongestCard:                           LongestCard.
  435. * LongestInt:                            LongestInt.
  436. * LongestReal:                           LongestReal.
  437. * LongestWord:                           LongestWord.
  438. * LongInt:                               LongInt.
  439. * LongReal <1>:                          LongReal.
  440. * LongReal:                              Real Types.
  441. * LongWord:                              LongWord.
  442. * Loops, Loop Control Statements:        Loop Control Statements.
  443. * Low:                                   Low.
  444. * LT:                                    LT.
  445. * Machine-dependent Type Implementation: Machine-dependent Type Implementation.
  446. * magic, internals:                      Tree nodes.
  447. * main program:                          Importing Libraries from Other Languages.
  448. * Mark:                                  Mark.
  449. * Max <1>:                               Max.
  450. * Max:                                   Operations for Integer and Ordinal Types.
  451. * MaxChar:                               MaxChar.
  452. * MaxInt:                                MaxInt.
  453. * MaxReal:                               MaxReal.
  454. * MedBool:                               MedBool.
  455. * MedCard:                               MedCard.
  456. * MedInt:                                MedInt.
  457. * MedReal:                               MedReal.
  458. * MedWord:                               MedWord.
  459. * Min <1>:                               Min.
  460. * Min:                                   Operations for Integer and Ordinal Types.
  461. * MinReal:                               MinReal.
  462. * MkDir:                                 MkDir.
  463. * mod <1>:                               Keywords.
  464. * mod:                                   mod.
  465. * module <1>:                            Keywords.
  466. * module:                                module.
  467. * Modules, source structure:             Modules.
  468. * Move:                                  Move.
  469. * MoveLeft:                              MoveLeft.
  470. * MoveRight:                             MoveRight.
  471. * MS Windows 95/98/NT <1>:               MS Windows 95/98/NT.
  472. * MS Windows 95/98/NT:                   Download.
  473. * MS-DOS <1>:                            MS-DOS or OS/2 with EMX.
  474. * MS-DOS:                                MS-DOS with DJGPP.
  475. * Name:                                  Name.
  476. * NE:                                    NE.
  477. * near:                                  near.
  478. * New <1>:                               New.
  479. * New <2>:                               Memory Management Routines.
  480. * New:                                   OOP.
  481. * NewCString:                            NewCString.
  482. * news:                                  News.
  483. * nil <1>:                               Keywords.
  484. * nil:                                   nil.
  485. * not <1>:                               Keywords.
  486. * not <2>:                               not.
  487. * not:                                   Operations for Integer and Ordinal Types.
  488. * Null:                                  Null.
  489. * object <1>:                            Keywords.
  490. * object:                                object.
  491. * Object Types, Data Types:              Object Types.
  492. * object-orientated programming:         OOP.
  493. * Objects:                               Exporting GPC Libraries to Other Languages.
  494. * Odd:                                   Odd.
  495. * of <1>:                                Keywords.
  496. * of:                                    of.
  497. * only <1>:                              Keywords.
  498. * only:                                  only.
  499. * OOP:                                   OOP.
  500. * operator <1>:                          Keywords.
  501. * operator:                              operator.
  502. * operator, Subroutine Declaration, Source Structure: The Operator.
  503. * Operators:                             Operators.
  504. * operators, built-in:                   Built-in Operators.
  505. * operators, user-defined:               User-defined Operators.
  506. * options, command line:                 Invoking GPC.
  507. * or <1>:                                Keywords.
  508. * or <2>:                                or.
  509. * or:                                    Operations for Integer and Ordinal Types.
  510. * or else:                               or else.
  511. * or_else <1>:                           Keywords.
  512. * or_else:                               or_else.
  513. * Ord:                                   Ord.
  514. * Ordinal Types, Intrinsic, Data Types:  Ordinal Types.
  515. * OS/2:                                  MS-DOS or OS/2 with EMX.
  516. * otherwise <1>:                         Keywords.
  517. * otherwise:                             otherwise.
  518. * Output:                                Output.
  519. * output file option:                    GPC Options.
  520. * Override:                              Override.
  521. * Pack:                                  Pack.
  522. * packed <1>:                            Keywords.
  523. * packed:                                packed.
  524. * Page:                                  Page.
  525. * PAnsiChar:                             PAnsiChar.
  526. * ParamCount <1>:                        ParamCount.
  527. * ParamCount:                            Accessing Command Line Arguments.
  528. * Parameter List, Subroutine Declaration, Source Structure: Subroutine Parameter List Declaration.
  529. * parameter passing, internals:          Parameter passing.
  530. * parameter, protected:                  Protected Parameters.
  531. * ParamStr <1>:                          ParamStr.
  532. * ParamStr:                              Accessing Command Line Arguments.
  533. * parser, internals:                     Language definition.
  534. * PChar:                                 PChar.
  535. * Pi:                                    Pi.
  536. * Pointer:                               Pointer.
  537. * pointer arithmetics:                   Pointer Arithmetics.
  538. * pointer types:                         Pointer Types.
  539. * Pointer, Intrinsic, Data Types:        Pointer (Intrinsic).
  540. * Polar <1>:                             Polar.
  541. * Polar:                                 Complex Number Operations.
  542. * Pos:                                   Pos.
  543. * Position <1>:                          Position.
  544. * Position:                              File Routines.
  545. * pow <1>:                               Keywords.
  546. * pow <2>:                               pow.
  547. * pow:                                   Complex Number Operations.
  548. * Pred <1>:                              Pred.
  549. * Pred:                                  Operations for Integer and Ordinal Types.
  550. * preprocessor:                          Compiler Directives.
  551. * private <1>:                           Keywords.
  552. * private:                               private.
  553. * procedural parameters, internals:      Parameter passing.
  554. * procedural type:                       Procedural Types.
  555. * procedure <1>:                         Keywords.
  556. * procedure:                             procedure.
  557. * Procedure Call, Statements, Source Structure: Procedure Call.
  558. * procedure, Subroutine Declaration, Source Structure: The Procedure.
  559. * procedures, predefined:                Library Routines.
  560. * program <1>:                           Keywords.
  561. * program:                               program.
  562. * programming in GPC:                    Programming.
  563. * Programs, source structure:            The Program.
  564. * property <1>:                          Keywords.
  565. * property:                              property.
  566. * protected <1>:                         Keywords.
  567. * protected <2>:                         protected.
  568. * protected:                             Importing Libraries from Other Languages.
  569. * protected, parameter:                  Protected Parameters.
  570. * PtrCard:                               PtrCard.
  571. * PtrDiffType:                           PtrDiffType.
  572. * PtrInt:                                PtrInt.
  573. * PtrWord:                               PtrWord.
  574. * public <1>:                            Keywords.
  575. * public:                                public.
  576. * published <1>:                         Keywords.
  577. * published:                             published.
  578. * Put <1>:                               Put.
  579. * Put:                                   File Routines.
  580. * qualified <1>:                         Keywords.
  581. * qualified:                             qualified.
  582. * Questions, Frequently Asked:           FAQ.
  583. * Random:                                Random.
  584. * Randomize:                             Randomize.
  585. * Re <1>:                                Re.
  586. * Re:                                    Complex Number Operations.
  587. * Read:                                  Read.
  588. * ReadLn:                                ReadLn.
  589. * ReadStr:                               ReadStr.
  590. * Real <1>:                              Real.
  591. * Real:                                  Real Types.
  592. * record <1>:                            Keywords.
  593. * record:                                record.
  594. * Record Types, Data Types:              Record Types.
  595. * record, variant:                       Variant Records.
  596. * register:                              register.
  597. * Release:                               Release.
  598. * Rename:                                Rename.
  599. * repeat <1>:                            Keywords.
  600. * repeat:                                repeat.
  601. * repeat, Statements, Source Structure:  repeat Statement.
  602. * Reset:                                 Reset.
  603. * resident <1>:                          Keywords.
  604. * resident:                              resident.
  605. * restricted <1>:                        Keywords.
  606. * restricted:                            restricted.
  607. * Result:                                Result.
  608. * Return:                                Return.
  609. * ReturnAddress:                         ReturnAddress.
  610. * Rewrite:                               Rewrite.
  611. * RmDir:                                 RmDir.
  612. * Root:                                  Root.
  613. * Round:                                 Round.
  614. * routines, predefined:                  Library Routines.
  615. * Run Time Library <1>:                  Run Time System.
  616. * Run Time Library:                      Library Routines.
  617. * Run Time System <1>:                   Run Time System.
  618. * Run Time System:                       Library Routines.
  619. * RunError:                              RunError.
  620. * schemata:                              Schema Types.
  621. * Seek:                                  Seek.
  622. * SeekRead <1>:                          SeekRead.
  623. * SeekRead:                              File Routines.
  624. * SeekUpdate <1>:                        SeekUpdate.
  625. * SeekUpdate:                            File Routines.
  626. * SeekWrite <1>:                         SeekWrite.
  627. * SeekWrite:                             File Routines.
  628. * segment <1>:                           Keywords.
  629. * segment:                               segment.
  630. * Self:                                  Self.
  631. * set <1>:                               Keywords.
  632. * set:                                   set.
  633. * Set Types, Data Types:                 Set Types.
  634. * SetFileTime:                           SetFileTime.
  635. * SetLength:                             SetLength.
  636. * SetType:                               SetType.
  637. * shl <1>:                               Keywords.
  638. * shl <2>:                               shl.
  639. * shl:                                   Operations for Integer and Ordinal Types.
  640. * ShortBool:                             ShortBool.
  641. * ShortCard:                             ShortCard.
  642. * ShortInt:                              ShortInt.
  643. * ShortReal <1>:                         ShortReal.
  644. * ShortReal:                             Real Types.
  645. * ShortWord:                             ShortWord.
  646. * shr <1>:                               Keywords.
  647. * shr <2>:                               shr.
  648. * shr:                                   Operations for Integer and Ordinal Types.
  649. * Sin <1>:                               Sin.
  650. * Sin:                                   Complex Number Operations.
  651. * Single <1>:                            Single.
  652. * Single:                                Real Types.
  653. * SizeOf:                                SizeOf.
  654. * SizeType:                              SizeType.
  655. * SmallInt:                              SmallInt.
  656. * source distributions, installing:      Compiling GPC.
  657. * source structures:                     Source Structures.
  658. * Sqr <1>:                               Sqr.
  659. * Sqr:                                   Complex Number Operations.
  660. * SqRt <1>:                              SqRt.
  661. * SqRt:                                  Complex Number Operations.
  662. * StandardError:                         StandardError.
  663. * StandardInput:                         StandardInput.
  664. * StandardOutput:                        StandardOutput.
  665. * Statements, Source Structures:         Statements.
  666. * static <1>:                            Keywords.
  667. * static:                                static.
  668. * StdErr:                                StdErr.
  669. * Str:                                   Str.
  670. * String:                                String.
  671. * String, Intrinsic, Data Types:         String Types.
  672. * String2CString:                        String2CString.
  673. * subrange types:                        Subrange Types.
  674. * Subroutine Declaration, Source Structures: Subroutine Declaration.
  675. * SubStr:                                SubStr.
  676. * Succ <1>:                              Succ.
  677. * Succ:                                  Operations for Integer and Ordinal Types.
  678. * support:                               Support.
  679. * Text:                                  Text.
  680. * TextWritable:                          TextWritable.
  681. * TFDD:                                  TFDDs.
  682. * then <1>:                              Keywords.
  683. * then:                                  then.
  684. * Time <1>:                              Time.
  685. * Time:                                  Date And Time Routines.
  686. * TimeStamp:                             TimeStamp.
  687. * to <1>:                                Keywords.
  688. * to:                                    to.
  689. * to begin do:                           to begin do.
  690. * to end do:                             to end do.
  691. * tree nodes, internals:                 Tree nodes.
  692. * Trim:                                  Trim.
  693. * True:                                  True.
  694. * Trunc:                                 Trunc.
  695. * Truncate:                              Truncate.
  696. * type <1>:                              Keywords.
  697. * type:                                  type.
  698. * type casts:                            Type Casts.
  699. * Type Declaration, Source Structures:   Type Declaration.
  700. * Type Definition Possibilities:         Type Definition Possibilities.
  701. * type of:                               type of.
  702. * TypeOf:                                TypeOf.
  703. * types, functional:                     Procedural Types.
  704. * types, initializers:                   Type Initializers.
  705. * types, Integer:                        Integer Types.
  706. * types, pointer:                        Pointer Types.
  707. * types, procedural:                     Procedural Types.
  708. * types, real:                           Real Types.
  709. * types, restricted:                     Restricted Types.
  710. * types, schema:                         Schema Types.
  711. * types, schemata:                       Schema Types.
  712. * types, subrange:                       Subrange Types.
  713. * types, variant records:                Variant Records.
  714. * UnBind:                                UnBind.
  715. * Unbind:                                File Routines.
  716. * unit <1>:                              Keywords.
  717. * unit:                                  unit.
  718. * Units, source structure:               Units.
  719. * Unpack:                                Unpack.
  720. * until <1>:                             Keywords.
  721. * until:                                 until.
  722. * UpCase:                                UpCase.
  723. * Update <1>:                            Update.
  724. * Update:                                File Routines.
  725. * uses <1>:                              Keywords.
  726. * uses:                                  uses.
  727. * Val:                                   Val.
  728. * value <1>:                             Keywords.
  729. * value:                                 value.
  730. * var <1>:                               Keywords.
  731. * var:                                   var.
  732. * var, Statements, Source Structure:     The Declaring Statement.
  733. * Variable Declaration, Source Structures: Variable Declaration.
  734. * view <1>:                              Keywords.
  735. * view:                                  view.
  736. * virtual <1>:                           Keywords.
  737. * virtual:                               virtual.
  738. * VMT:                                   Exporting GPC Libraries to Other Languages.
  739. * Void:                                  Void.
  740. * volatile <1>:                          Keywords.
  741. * volatile:                              volatile.
  742. * while <1>:                             Keywords.
  743. * while:                                 while.
  744. * while, Statements, Source Structure:   while Statement.
  745. * Windows 95/98/NT, MS <1>:              MS Windows 95/98/NT.
  746. * Windows 95/98/NT, MS:                  Download.
  747. * with <1>:                              Keywords.
  748. * with:                                  with.
  749. * with, Statements, Source Structure:    with Statement.
  750. * Word:                                  Word.
  751. * WordBool:                              WordBool.
  752. * Write:                                 Write.
  753. * WriteLn:                               WriteLn.
  754. * WriteStr:                              WriteStr.
  755. * xor <1>:                               Keywords.
  756. * xor <2>:                               xor.
  757. * xor:                                   Operations for Integer and Ordinal Types.
  758.  
  759.  
  760.